深度强化学习-Policy Gradient基本实现

1、什么是 Policy Gradients

其实在引言部分我们已经介绍了策略梯度的基本思想，就是直接根据状态输出动作或者动作的概率。那么怎么输出呢，最简单的就是使用神经网络啦！
我们使用神经网络输入当前的状态，网络就可以输出我们在这个状态下采取每个动作的概率，那么网络应该如何训练来实现最终的收敛呢？
我们之前在训练神经网络时，使用最多的方法就是反向传播算法，我们需要一个误差函数，通过梯度下降来使我们的损失最小。但对于强化学习来说，我们不知道动作的正确与否，只能通过奖励值来判断这个动作的相对好坏。基于上面的想法，我们有个非常简单的想法：

如果一个动作得到的reward多，那么我们就使其出现的概率增加，如果一个动作得到的reward少，我们就使其出现的概率减小。

根据这个思想，我们构造如下的损失函数：loss= -log(prob)*vt

我们简单用白话介绍一下上面这个损失函数的合理性，那么至于从数学角度上为什么要使用上面的损失函数，可以参考：Why we consider log likelihood instead of Likelihood in Gaussian Distribution。

上式中log(prob)表示在状态 s 对所选动作 a 的吃惊度, 如果概率越小, 反向的log(prob) 反而越大. 而vt代表的是当前状态s下采取动作a所能得到的奖励，这是当前的奖励和未来奖励的贴现值的求和。也就是说，我们的策略梯度算法必须要完成一个完整的eposide才可以进行参数更新，而不是像值方法那样，每一个(s,a,r,s’)都可以进行参数更新。如果在prob很小的情况下, 得到了一个大的Reward, 也就是大的vt, 那么-log(prob)*vt就更大, 表示更吃惊, (我选了一个不常选的动作, 却发现原来它能得到了一个好的 reward, 那我就得对我这次的参数进行一个大幅修改)。

这就是 -log(prob)*vt的物理意义啦.Policy Gradient的核心思想是更新参数时有两个考虑：如果这个回合选择某一动作，下一回合选择该动作的概率大一些，然后再看奖惩值，如果奖惩是正的，那么会放大这个动作的概率，如果奖惩是负的，就会减小该动作的概率。

策略梯度的过程如下图所示：

我们在介绍代码实战之前，最后在强调Policy Gradient的一些细节：

算法输出的是动作的概率，而不是Q值。
损失函数的形式为：loss= -log(prob)*vt
需要一次完整的episode才可以进行参数的更新

2、Policy Gradient算法实现

我们通过Policy Gradient算法来实现让钟摆倒立的过程。

本文的代码思路完全按照policy gradient的过程展开。

定义参数
首先，我们定义了一些模型的参数：

self.ep_obs,self.ep_as,self.ep_rs分别存储了当前episode的状态，动作和奖励。

self.n_actions = n_actions
self.n_features = n_features
self.lr = learning_rate
self.gamma = reward_decay

self.ep_obs,self.ep_as,self.ep_rs = [],[],[]

定义模型输入
模型的输入包括三部分，分别是观察值，动作和奖励值。

with tf.name_scope('inputs'):
    self.tf_obs = tf.placeholder(tf.float32,[None,self.n_features],name='observation')
    self.tf_acts = tf.placeholder(tf.int32,[None,],name='actions_num')
    self.tf_vt = tf.placeholder(tf.float32,[None,],name='actions_value')

构建模型
我们的模型定义了两层的神经网络，网络的输入是每次的观测值，而输出是该状态下采取每个动作的概率，这些概率在最后会经过一个softmax处理

layer = tf.layers.dense(
    inputs = self.tf_obs,
    units = 10,
    activation= tf.nn.tanh,
    kernel_initializer=tf.random_normal_initializer(mean=0,stddev=0.3),
    bias_initializer= tf.constant_initializer(0.1),
    name='fc1'
)

all_act = tf.layers.dense(
    inputs = layer,
    units = self.n_actions,
    activation = None,
    kernel_initializer=tf.random_normal_initializer(mean=0,stddev=0.3),
    bias_initializer = tf.constant_initializer(0.1),
    name='fc2'
)

self.all_act_prob = tf.nn.softmax(all_act,name='act_prob')

模型的损失
我们之前介绍过了，模型的损失函数计算公式为：loss= -log(prob)*vt，我们可以直接使用tf.nn.sparse_softmax_cross_entropy_with_logits 来计算前面一部分，即-log(prob)，不过为了更清楚的显示我们的计算过程，我们使用了如下的方式：

with tf.name_scope('loss'):
    #neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.all_act_prob,labels =self.tf_acts)

    neg_log_prob = tf.reduce_sum(-tf.log(self.all_act_prob) * tf.one_hot(indices=self.tf_acts,depth=self.n_actions),axis=1)
    loss = tf.reduce_mean(neg_log_prob * self.tf_vt)

而我们选择AdamOptimizer优化器进行参数的更新：

1 2	with tf.name_scope('train'): self.train_op = tf.train.AdamOptimizer(self.lr).minimize(loss)

动作选择
我们这里动作的选择不再根据贪心的策略来选择了，而是根据输出动作概率的softmax值：

def choose_action(self,observation):
    prob_weights = self.sess.run(self.all_act_prob,feed_dict={self.tf_obs:observation[np.newaxis,:]})
    action = np.random.choice(range(prob_weights.shape[1]),p=prob_weights.ravel())
    return action

存储经验
之前说过，policy gradient是在一个完整的episode结束后才开始训练的，因此，在一个episode结束前，我们要存储这个episode所有的经验，即状态，动作和奖励。

def store_transition(self,s,a,r):
    self.ep_obs.append(s)
    self.ep_as.append(a)
    self.ep_rs.append(r)

计算奖励的贴现值
我们之前存储的奖励是当前状态s采取动作a获得的即时奖励，而当前状态s采取动作a所获得的真实奖励应该是即时奖励加上未来直到episode结束的奖励贴现和。

def _discount_and_norm_rewards(self):
    discounted_ep_rs = np.zeros_like(self.ep_rs)
    running_add = 0
    # reserved 返回的是列表的反序，这样就得到了贴现求和值。
    for t in reversed(range(0,len(self.ep_rs))):
        running_add = running_add * self.gamma + self.ep_rs[t]
        discounted_ep_rs[t] = running_add

    discounted_ep_rs -= np.mean(discounted_ep_rs)
    discounted_ep_rs /= np.std(discounted_ep_rs)
    return discounted_ep_rs

模型训练
在定义好上面所有的部件之后，我们就可以编写模型训练函数了，这里需要注意的是，我们喂给模型的并不是我们存储的奖励值，而是在经过上一步计算的奖励贴现和。另外，我们需要在每一次训练之后清空我们的经验池。

def learn(self):
    discounted_ep_rs_norm = self._discount_and_norm_rewards()

    self.sess.run(self.train_op,feed_dict={
        self.tf_obs:np.vstack(self.ep_obs),
        self.tf_acts:np.array(self.ep_as),
        self.tf_vt:discounted_ep_rs_norm,
    })

    self.ep_obs,self.ep_as,self.ep_rs = [],[],[]
    return discounted_ep_rs_norm

好了，模型相关的代码我们就介绍完了，如何调用这个模型的代码相信大家一看便明白，我们就不再介绍啦。